// orders.js
const app = getApp()

Page({
  data: {
    activeTab: 'all',
    orders: [],
    filteredOrders: [],
    totalOrders: 0,
    pendingOrders: 0,
    cookingOrders: 0,
    completedOrders: 0,
    rejectedOrders: 0,
    userInfo: null,
    showGlobalLoginModal: false
  },

  onLoad() {
    console.log('安排记录页面加载')
    console.log('全局安排数据:', app.globalData.orders)
    
    // 设置用户信息
    this.setData({
      userInfo: app.globalData.userInfo
    })
    
    // 如果没有安排数据，创建一个测试安排
    if (!app.globalData.orders || app.globalData.orders.length === 0) {
      console.log('没有安排数据，创建测试安排')
      const testArrangement = {
        _id: 'test_' + Date.now(), // 使用 _id 字段，与云数据库一致
        id: Date.now(), // 保留 id 字段作为备用
        status: 'pending',
        createTime: new Date().toLocaleString(),
        familyId: 'xiaoweichufang', // 添加家庭ID
        items: [], // 空数组，本地不需要默认服务
        totalAmount: 0,
        totalItems: 0,
        note: ''
      }
      
      app.globalData.orders = [testArrangement]
      console.log('测试安排创建成功:', testArrangement)
    }
    
    this.loadOrders()
    
    // 设置定时刷新，每10秒检查一次新数据（更频繁的刷新）
    this.refreshTimer = setInterval(() => {
      console.log('定时检查安排数据更新...')
      this.loadOrders()
    }, 10000) // 10秒
  },

  onShow() {
    console.log('安排记录页面显示')
    console.log('当前全局安排数据:', app.globalData.orders)
    
    // 更新用户信息
    this.setData({
      userInfo: app.globalData.userInfo
    })
    
    // 监听全局登录弹框状态
    this.setData({
      showGlobalLoginModal: app.globalData.showGlobalLoginModal
    })
    
    // 确保事件监听已设置
    this.setupEventListeners()
    
    // 检查是否需要刷新安排统计
    if (app.globalData.needRefreshUserOrderStats) {
      console.log('检测到需要刷新用户安排统计，开始刷新...')
      app.globalData.needRefreshUserOrderStats = false
      this.loadOrders()
    } else {
      this.loadOrders()
    }
    
    // 初始化TabBar页面（检查并应用等待中的图标配置）
    app.initTabBarPage()
  },

  onUnload() {
    // 页面卸载时清除定时器
    if (this.refreshTimer) {
      clearInterval(this.refreshTimer)
      this.refreshTimer = null
    }
    
    // 清理事件监听
    this.cleanupEventListeners()
  },


  // 加载安排数据
  loadOrders() {
    const orders = app.globalData.orders || []
    
    console.log('原始安排数据:', orders)
    console.log('安排数量:', orders.length)
    
    // 只显示当前用户的安排
    const currentUserId = app.globalData.userInfo?._id
    if (!currentUserId) {
      console.error('用户ID不存在，无法加载安排')
      this.setData({
        orders: [],
        filteredOrders: [],
        totalOrders: 0,
        pendingOrders: 0,
        cookingOrders: 0,
        completedOrders: 0,
        rejectedOrders: 0
      })
      return
    }
    
    // 过滤出当前用户的安排
    const userOrders = orders.filter(order => order.userId === currentUserId)
    console.log('当前用户ID:', currentUserId)
    console.log('用户安排数量:', userOrders.length)
    
    // 预处理安排数据，确保时间格式正确
    const processedOrders = userOrders.map(order => {
      console.log('处理安排:', order._id, 'createTime:', order.createTime, '类型:', typeof order.createTime)
      
      // 确保createTime是正确格式
      if (order.createTime) {
        // 如果createTime是Date对象，转换为字符串
        if (order.createTime instanceof Date) {
          order.createTime = order.createTime.toLocaleString('zh-CN', {
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit'
          })
          console.log('Date对象转换后:', order.createTime)
        }
        // 如果createTime是时间戳，转换为字符串
        else if (typeof order.createTime === 'number') {
          order.createTime = new Date(order.createTime).toLocaleString('zh-CN', {
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit'
          })
          console.log('时间戳转换后:', order.createTime)
        }
        // 如果是字符串，检查是否为空
        else if (typeof order.createTime === 'string') {
          console.log('字符串类型:', order.createTime)
          if (!order.createTime.trim()) {
            order.createTime = '未知时间'
            console.log('空字符串，设置为未知时间')
          }
        }
      } else {
        console.log('createTime为空，设置为默认时间')
        order.createTime = '未知时间'
      }
      
      console.log('最终处理结果:', order.createTime)
      return order
    })
    
    console.log('处理后的用户安排数据:', processedOrders)
    
    this.setData({ orders: processedOrders })
    this.updateOrderStats()
    this.filterOrders()
  },

  // 更新安排统计
  updateOrderStats() {
    const { orders } = this.data
    const totalOrders = orders.length
    const pendingOrders = orders.filter(order => order.status === 'pending').length
    const cookingOrders = orders.filter(order => order.status === 'cooking').length
    const completedOrders = orders.filter(order => order.status === 'completed').length
    const rejectedOrders = orders.filter(order => order.status === 'rejected').length

    this.setData({
      totalOrders,
      pendingOrders,
      cookingOrders,
      completedOrders,
      rejectedOrders
    })
  },

  // 切换标签页
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab
    this.setData({ activeTab: tab })
    this.filterOrders()
  },

  // 筛选安排
  filterOrders() {
    const { orders, activeTab } = this.data
    let filteredOrders = []

    if (activeTab === 'all') {
      filteredOrders = orders
    } else {
      filteredOrders = orders.filter(order => order.status === activeTab)
    }

    this.setData({ filteredOrders })
  },

  // 获取状态文本
  getStatusText(status) {
    const statusMap = {
      'pending': '待确认',
      'cooking': '制作中',
      'completed': '已完成',
      'cancelled': '已取消',
      'rejected': '已拒绝'
    }
    return statusMap[status] || status
  },

  // 格式化时间显示
  formatTime(time) {
    console.log('formatTime被调用，参数:', time, '类型:', typeof time)
    
    if (!time) {
      console.log('time为空，返回未知时间')
      return '未知时间'
    }
    
    // 如果是字符串，直接返回
    if (typeof time === 'string') {
      console.log('字符串类型，直接返回:', time)
      return time
    }
    
    // 如果是Date对象，格式化为字符串
    if (time instanceof Date) {
      const result = time.toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit'
      })
      console.log('Date对象转换结果:', result)
      return result
    }
    
    // 如果是时间戳，转换为Date对象再格式化
    if (typeof time === 'number') {
      const result = new Date(time).toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit'
      })
      console.log('时间戳转换结果:', result)
      return result
    }
    
    // 其他情况，尝试转换为字符串
    try {
      const result = String(time)
      console.log('其他类型转换结果:', result)
      return result
    } catch (e) {
      console.log('转换失败，返回未知时间')
      return '未知时间'
    }
  },

  // 取消安排
  cancelOrder(e) {
    const orderId = e.currentTarget.dataset.id
    wx.showModal({
      title: '确认取消',
      content: '确定要取消这个安排吗？',
      success: (res) => {
        if (res.confirm) {
          this.cancelOrderById(orderId)
        }
      }
    })
  },

  // 执行取消安排
  async cancelOrderById(orderId) {
    try {
      console.log('开始取消安排:', orderId)
      
      // 检查安排ID是否有效
      if (!orderId) {
        console.error('安排ID为空，无法取消安排')
        wx.showToast({ title: '安排ID无效', icon: 'error' })
        return
      }
      
      // 先更新云数据库
      const { orderService } = require('../../utils/cloud.js')
      const result = await orderService.updateOrderStatus(orderId, 'cancelled')
      
      if (result.success) {
        console.log('安排状态已同步到云数据库')
        
        // 云数据库更新成功后，再更新本地数据
        const orders = app.globalData.orders
        // 优先使用 _id 字段，如果没有则使用 id 字段
        const orderIndex = orders.findIndex(order => 
          order._id === orderId || order.id === orderId
        )
        
        if (orderIndex !== -1) {
          orders[orderIndex].status = 'cancelled'
          app.globalData.orders = orders
          
          // 刷新本地页面
          this.loadOrders()
          
          // 显示成功消息
          wx.showToast({ title: '安排已取消', icon: 'success' })
          
          // 通知厨师后台刷新（通过全局标记）
          this.notifyChefPageRefresh()
          
          console.log('安排取消完成，本地数据已同步')
        } else {
          console.error('本地安排数据中未找到安排:', orderId)
          wx.showToast({ title: '安排数据异常', icon: 'error' })
        }
      } else {
        console.error('同步安排状态到云数据库失败:', result.error)
        wx.showToast({ title: '取消安排失败', icon: 'error' })
      }
    } catch (error) {
      console.error('取消安排失败:', error)
      wx.showToast({ title: '取消安排失败', icon: 'error' })
    }
  },

  // 重新安排
  reorder(e) {
    const orderId = e.currentTarget.dataset.id
    // 优先使用 _id 字段，如果没有则使用 id 字段
    const order = app.globalData.orders.find(order => 
      order._id === orderId || order.id === orderId
    )
    
    if (order) {
      // 将安排中的服务重新添加到选择列表
      order.items.forEach(item => {
        app.addToCart(item, item.quantity, item.note)
      })
      
      wx.showToast({ title: '已添加到选择列表', icon: 'success' })
      
      // 跳转到服务选择页面
      setTimeout(() => {
        wx.switchTab({ url: '/pages/cart/cart' })
      }, 1000)
    }
  },

  // 去选择服务
  goToDishes() {
    wx.switchTab({ url: '/pages/dishes/dishes' })
  },

  // 去登录
  goToLogin() {
    const app = getApp()
    app.showLoginModal()
  },

  // 关闭全局登录弹框
  onGlobalLoginModalClose() {
    this.setData({
      showGlobalLoginModal: false
    })
    // 同步全局状态
    const app = getApp()
    app.globalData.showGlobalLoginModal = false
  },

  // 全局登录成功回调
  onGlobalLoginSuccess() {
    console.log('全局登录成功，刷新页面数据')
    // 刷新安排数据
    this.loadOrders()
  },

  // 查看安排详情
  viewOrderDetail(e) {
    const orderId = e.currentTarget.dataset.id
    // 这里可以跳转到安排详情页面
    wx.showToast({ title: '安排详情功能开发中', icon: 'none' })
  },

  // 通知厨师后台刷新订单统计
  notifyChefPageRefresh() {
    // 使用全局状态管理来通知厨师后台刷新
    if (app.globalData) {
      app.globalData.needRefreshChefOrderStats = true
      console.log('已设置厨师后台刷新标记')
    }
  },
  
  // 设置事件监听
  setupEventListeners() {
    // 监听订单状态变化事件
    if (app.globalData.eventBus) {
      // 先移除可能存在的监听器，避免重复
      app.globalData.eventBus.off('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      app.globalData.eventBus.on('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      console.log('✅ 订单页面已设置事件监听')
      
      // 监听全局登录弹框显示事件
      app.globalData.eventBus.on('showGlobalLoginModal', () => {
        this.setData({
          showGlobalLoginModal: true
        })
      })
    } else {
      console.error('❌ 事件总线未初始化，无法设置事件监听')
      // 延迟重试
      setTimeout(() => {
        this.setupEventListeners()
      }, 500)
    }
  },
  
  // 清理事件监听
  cleanupEventListeners() {
    if (app.globalData.eventBus) {
      app.globalData.eventBus.off('orderStatusChanged', this.handleOrderStatusChange.bind(this))
      app.globalData.eventBus.off('showGlobalLoginModal')
      console.log('订单页面已清理事件监听')
    }
  },
  
  // 处理订单状态变化事件
  handleOrderStatusChange(data) {
    console.log('收到订单状态变化通知:', data)
    
    // 检查是否是当前用户的订单
    const currentUserId = app.globalData.userInfo?._id
    if (data.userId && data.userId !== currentUserId) {
      console.log('订单不属于当前用户，忽略通知')
      return
    }
    
    // 延迟1秒刷新，确保云数据库更新完成
    setTimeout(async () => {
      console.log('延迟刷新订单数据...')
      await this.loadOrders()
    }, 1000)
    
    // 显示提示
    wx.showToast({
      title: '订单状态已更新',
      icon: 'success',
      duration: 1500
    })
  }
}) 